PR Summary

Medium Risk
Touches core multistore access paths used during commits and queries; incorrect locking could cause deadlocks or stale reads, but the change aligns getters with existing mutex usage elsewhere.

Overview
Adds RLock/RUnlock around reads of the ckvStores map in GetStore, GetKVStore, and GetCommitKVStore so concurrent readers do not race writers that replace or update that map during commit or load.

Adds TestGetCommitKVStore_ReaderRespectsWriteLock, which holds the write lock, proves GetCommitKVStore blocks until it is released, and checks the goroutine sees the updated store after the map is swapped.

^{Reviewed by Cursor Bugbot for commit fd1b008. Bugbot is set up for automated code reviews on this repo. Configure here.}

The latest Buf updates on your PR. Results from workflow Buf / buf (pull_request).

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 58.20%. Comparing base (c4e1a2a) to head (fd1b008).

@@            Coverage Diff             @@
##             main    #3517      +/-   ##
==========================================
- Coverage   59.05%   58.20%   -0.86%     
==========================================
  Files        2205     2132      -73     
  Lines      182317   173954    -8363     
==========================================
- Hits       107672   101252    -6420     
+ Misses      64945    63681    -1264     
+ Partials     9700     9021     -679     

Could we tighten the test? Something like:

func TestGetCommitKVStore_ReaderRespectsWriteLock(t *testing.T) {
    store := &Store{
        storeKeys: map[string]types.StoreKey{},
        ckvStores: map[types.StoreKey]types.CommitKVStore{},
    }
    key := types.NewKVStoreKey("bank")
    store.storeKeys[key.Name()] = key
    store.ckvStores[key] = mem.NewStore()

    store.mtx.Lock()

    readDone := make(chan types.CommitKVStore, 1)
    go func() {
        readDone <- store.GetCommitKVStore(key)
    }()

    select {
    case <-readDone:
        t.Fatal("GetCommitKVStore returned while write lock held — RLock missing")
    case <-time.After(50 * time.Millisecond):
    }

    newVal := mem.NewStore()
    store.ckvStores = map[types.StoreKey]types.CommitKVStore{key: newVal}
    store.mtx.Unlock()

    require.Same(t, newVal, <-readDone)
}

This deterministically verifies the RLock is doing its job — the read blocks while the write lock is held, then observes the post-write value — instead of relying on the scheduler to overlap two unsynchronized goroutines and the race detector to notice.

@codex review this pr

To use Codex here, create a Codex account and connect to github.